﻿// 1209. [模拟]呼叫转移 https://oj.rnd.huawei.com/problems/1209/details
// 4状态idle，busy，no-response，unreachable
//呼叫转移是指您的电话无法接听或您不愿接电话，可以将来电转移到其它电话号码上。它是电信业一项传统通信业务，又称呼叫前转、呼入转移。
//用户被呼叫时的状态有4种：idle，busy，no-response，unreachable
//用户可登记的5种呼叫转移，格式为type number，type代表转移种类，
// number代表转移号码： type为
// 0：无条件转移，优先级最高，用户处于任何状态都触发此转移 type为
// 1：用户状态busy时触发此转移 type为 2：用户状态no-response时触发此转移 type为
// 3：用户状态unreachable时触发此转移 type为
// 4：默认转移，优先级最低，用户不是idle状态时，且无法触发上述四种转移，触发此转移
//注：同一个状态可登记多次，以最后一次登记为准。
//现给出某一用户当前的用户状态，以及其登记的若干个呼叫转移号码，请输出最终的呼叫结果：
//若发生转移，则输出转移号码
//若用户状态为idle，且未发生转移时，则呼叫本机成功，输出success
//若呼叫失败：既没有发生转移，也没有呼叫本机成功，则输出failure。例如，用户状态为
// busy，但用户既未登记 type 为 0 或 1 或 4 的呼叫转移，则呼叫失败。 输入
//第一行是数字 num 和 字符串 status：num代表呼叫转移登记的次数（ 0 < N <=
// 20），status表示用户被呼叫时的状态。 接下来 num
//行是用户的呼叫转移登记操作，转移号码长度 6-15位，用例保证输入合法。 输出
//一个字符串，代表最终的呼叫结果 输入 3 busy 2 18912345678 4 18912345678 4
// 13312345567 输出 13312345567 用户busy，且没有登记 busy
//转移，但登记默认转移，呼叫转移到默认转移号码。 默认转移号码已最后一次登记为准
//输入 1 no-response
// 3 075587678100
//输出 failure
//用户no-response，没有登记no-response转移，也没有登记默认转移，呼叫失败。
//输入 1 idle
// 3 075587678100
//输出 success
//用户idle，且没有登记无条件转移，呼叫成功

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;

#define DEBUG
#ifdef DEBUG
#define PF(...) printf(__VA_ARGS__)
#else
#define PF(...)
#endif

#include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;

enum { Eidle = 0, Ebusy, EnoResponse, Eunreachable };

enum {
  Eforward_no_condition = 0,
  Eforward_busy,
  Eforward_noResponse,
  Eforward_unreachable,
  Eforward_default,
};
class Solution {
 public:
  // 待实现函数，在此函数中填入答题代码;
  string Calling(const string &status,
                 const vector<pair<int, string>> &regCallForwardNums) {
    string result;
    map<int, string> mapForward;
    for (auto [stat, phone] : regCallForwardNums) {
      mapForward[stat] = phone;
    }
    if (mapForward.count(Eforward_no_condition) > 0) {
      result = mapForward[Eforward_no_condition];
    }
    // 4状态idle，busy，no-response，unreachable
    else if (mapForward.count(Eforward_noResponse) > 0 &&
             status == "no-response") {
      result = mapForward[Eforward_noResponse];
    } else if (mapForward.count(Eforward_unreachable) > 0 &&
               status == "unreachable") {
      result = mapForward[Eforward_unreachable];
    } else if (mapForward.count(Eforward_busy) > 0 && status == "busy") {
      result = mapForward[Eforward_busy];
    } else if (mapForward.count(Eforward_default) > 0 && status != "idle") {
      result = mapForward[Eforward_default];
    }
    if (status == "idle" && result.empty()) {
      result = "success";
    }
    if (result.empty()) {
      result = "failure";
    }
    return result;
  }
};

// 以下为考题输入输出框架，此部分代码不建议改动
inline string ReadLine() {
  string line;
  getline(cin, line);
  return line;
}

inline vector<string> ReadLines(int size) {
  vector<string> lines(size);
  for (int i = 0; i < size; ++i) {
    lines[i] = ReadLine();
  }
  return lines;
}

inline pair<string, string> SplitPair(const string &word, char delimeter) {
  auto pos = word.find(delimeter);
  return make_pair(word.substr(0, pos), word.substr(pos + 1));
}

int main() {
  pair<string, string> p = SplitPair(ReadLine(), ' ');
  int n = stoi(p.first);
  string status = p.second;
  vector<string> lines = ReadLines(n);
  vector<pair<int, string>> regCallForwardNums;
  for (auto s : lines) {
    p = SplitPair(s, ' ');
    regCallForwardNums.push_back(make_pair(stoi(p.first), p.second));
  }

  Solution solu;
  string out = solu.Calling(status, regCallForwardNums);
  cout << out << endl;
  return 0;
}
